package com.sgb.link.utils;

import android.text.InputFilter;
import android.text.Spanned;
import android.text.TextUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 文本输入过滤器
 * AndyCheng
 */
public class JiCaiEditInputFilter implements InputFilter {

    /**
     * 最大数字
     */
    public double MAX_VALUE = 9999999;
    /**
     * 最小数
     */
    public double MIN_VALUE = 0;
    /**
     * 小数点后的数字的位数
     */
    public int POINTER_LENGTH = 2;

    private static final String POINTER = ".";

    Pattern p;

    public JiCaiEditInputFilter() {
        //用于匹配输入的是0-9  .  这几个数字和字符
        p = Pattern.compile("([0-9]|\\.)*");
    }

    /**
     * @param max    最大数
     * @param length 小数点位数
     */
    public JiCaiEditInputFilter(double max, int length) {
        MAX_VALUE = max;
        POINTER_LENGTH = length;
        //用于匹配输入的是0-9  .  这几个数字和字符
        p = Pattern.compile("([0-9]|\\.)*");
    }

    /**
     * @param max    最大数
     * @param min    最小数(length=0时生效)
     * @param length 小数点位数
     */
    public JiCaiEditInputFilter(double max, double min, int length) {
        MAX_VALUE = max;
        MIN_VALUE = min;
        POINTER_LENGTH = length;
        if (length==0){
            //用于匹配输入的是0-9  .  这几个数字和字符
            p = Pattern.compile("([0-9])*");
        }else {
            p = Pattern.compile("([0-9]|\\.)*");
        }
    }


    /**
     * source    新输入的字符串
     * start    新输入的字符串起始下标，一般为0
     * end    新输入的字符串终点下标，一般为source长度-1
     * dest    输入之前文本框内容
     * dstart    原内容起始坐标，一般为0
     * dend    原内容终点坐标，一般为dest长度-1
     */

    @Override
    public CharSequence filter(CharSequence source, int start, int end,
                               Spanned dest, int dstart, int dend) {
        //验证删除等按键
        if (TextUtils.isEmpty(source)) {
            return "";
        }
        Matcher matcher = p.matcher(source);
        if (!matcher.matches()) {
            return "";
        }
        //已经输入小数点的情况下，只能输入数字
        if (dest.toString().contains(POINTER)) {
            if (POINTER.contentEquals(source)) { //只能输入一个小数点
                return "";
            }
            //验证小数点精度，保证小数点后只能输入多少位
            int index = dest.toString().indexOf(POINTER);
            int length = dest.toString().substring(index).length();
            // dstart > index 输入位置在原点之后，
            if (dstart > index && length == POINTER_LENGTH + 1) {
                return "";
            }
        } else {
            //限制小数点位数
            if (POINTER_LENGTH > 0) {
                if (source.equals(POINTER) && dest.toString().length() == 0) {
                    return "0.";
                }
            } else {
                if (source.equals(POINTER)) {
                    return "";
                }
            }
        }
        //限制大小
        String inputStr = dest.toString().substring(0, dstart) + source + dest.toString().substring(dstart, dest.length());
        double input = Double.parseDouble(inputStr);
        if (isInRange(MIN_VALUE, MAX_VALUE, input)) {
            return null;
        } else {
            if (POINTER_LENGTH > 0 && (inputStr.equals("0.0") || inputStr.equals("0.00"))) { // 忽略0.0 0.00等情况
                return null;
            }
        }
        return "";
    }

    private boolean isInRange(double a, double b, double c) {
        return b > a ? c >= a && c <= b : c >= b && c <= a;
    }
}